import { BaseStorageService, PROJECT_CONFIG, StorageConfig } from './storage/baseStorageService';
import { stockPlanTransformer } from '../config/fieldMappings';

// 证券投资计划数据接口
export interface SavedStockPlan {
  id: string;
  stockCode: string;
  stockName: string;
  currentPrice: number;           // 当前价格
  maxDrawdown: number;           // 历史最大回撤
  totalShares: number;           // 目标总份额（必须是100的整数倍）
  buyTimes: number;              // 计划买入次数
  strategy: string;              // 投资策略
  averagePrice: number;          // 预期平均成本
  riskLevel: string;             // 风险等级
  maxLoss: number;               // 最大可能亏损
  totalAmount: number;           // 总投资金额（计算得出）
  
  // 证券特有字段
  minLots: number;               // 最小购买手数（通常为1手=100份）
  lotSize: number;               // 每手份数（通常为100）
  stockType: 'STOCK' | 'ETF' ;// 证券类型
  trackingIndex?: string;         // 跟踪指数
  managementFee: number;         // 管理费率
  
  createdAt?: string;
  updatedAt?: string;
}

// 证券投资计划服务类 - 继承基础存储服务
class StockPlanService extends BaseStorageService<SavedStockPlan> {
  constructor(config: StorageConfig = { type: 'indexedDB' }) {
    // 使用项目统一配置中定义的证券存储名称，并传入字段转换器
    super(PROJECT_CONFIG.STORE_NAMES.STOCK_PLANS, config, stockPlanTransformer);
  }

  // 业务特定的方法 - 保存证券投资计划
  async saveStockPlan(plan: SavedStockPlan): Promise<void> {
    // 验证用户登录状态
    const { isUserAuthenticated } = await import('../utils/userContext');
    if (!(await isUserAuthenticated())) {
      throw new Error('用户未登录，无法保存证券投资计划');
    }
    
    // 验证证券特有的业务规则
    this.validateStockPlan(plan);
    return this.save(plan);
  }

  // 业务特定的方法 - 获取所有证券投资计划
  async getStockPlans(): Promise<SavedStockPlan[]> {
    return this.getAll();
  }

  // 业务特定的方法 - 根据ID获取证券投资计划
  async getStockPlanById(id: string): Promise<SavedStockPlan | null> {
    return this.getById(id);
  }

  // 业务特定的方法 - 删除证券投资计划
  async deleteStockPlan(id: string): Promise<void> {
    return this.delete(id);
  }

  // 业务特定的方法 - 批量删除证券投资计划
  async deleteStockPlans(ids: string[]): Promise<void> {
    return this.deleteMany(ids);
  }

  // 业务特定的方法 - 根据证券代码查询
  async getStockPlansByCode(stockCode: string): Promise<SavedStockPlan[]> {
    const allPlans = await this.getStockPlans();
    return allPlans.filter(plan => plan.stockCode === stockCode);
  }

  // 业务特定的方法 - 根据证券类型查询
  async getStockPlansByType(stockType: SavedStockPlan['stockType']): Promise<SavedStockPlan[]> {
    const allPlans = await this.getStockPlans();
    return allPlans.filter(plan => plan.stockType === stockType);
  }

  // 业务特定的方法 - 根据跟踪指数查询
  async getStockPlansByIndex(trackingIndex: string): Promise<SavedStockPlan[]> {
    const allPlans = await this.getStockPlans();
    return allPlans.filter(plan => plan.trackingIndex?.includes(trackingIndex));
  }

  // 业务特定的方法 - 根据风险等级查询
  async getStockPlansByRiskLevel(riskLevel: string): Promise<SavedStockPlan[]> {
    const allPlans = await this.getStockPlans();
    return allPlans.filter(plan => plan.riskLevel === riskLevel);
  }

  // 业务特定的方法 - 获取证券投资统计信息
  async getStockInvestmentStatistics(): Promise<{
    totalPlans: number;
    totalInvestment: number;
    totalShares: number;
    averageAmount: number;
    typeDistribution: Record<string, number>;
    riskDistribution: Record<string, number>;
    averageManagementFee: number;
  }> {
    const plans = await this.getStockPlans();
    
    return {
      totalPlans: plans.length,
      totalInvestment: plans.reduce((sum, plan) => sum + plan.totalAmount, 0),
      totalShares: plans.reduce((sum, plan) => sum + plan.totalShares, 0),
      averageAmount: plans.length > 0 ? plans.reduce((sum, plan) => sum + plan.totalAmount, 0) / plans.length : 0,
      typeDistribution: plans.reduce((acc, plan) => {
        acc[plan.stockType] = (acc[plan.stockType] || 0) + 1;
        return acc;
      }, {} as Record<string, number>),
      riskDistribution: plans.reduce((acc, plan) => {
        acc[plan.riskLevel] = (acc[plan.riskLevel] || 0) + 1;
        return acc;
      }, {} as Record<string, number>),
      averageManagementFee: plans.length > 0 ? plans.reduce((sum, plan) => sum + plan.managementFee, 0) / plans.length : 0
    };
  }

  // 验证证券投资计划的业务规则
  private validateStockPlan(plan: SavedStockPlan): void {
    // 验证份额必须是手数的整数倍
    if (plan.totalShares % plan.lotSize !== 0) {
      throw new Error(`证券份额必须是${plan.lotSize}的整数倍`);
    }

    // 验证最小购买手数
    if (plan.totalShares < plan.minLots * plan.lotSize) {
      throw new Error(`证券份额不能少于${plan.minLots}手（${plan.minLots * plan.lotSize}份）`);
    }

    // 验证证券代码格式（简单验证）
    if (!plan.stockCode || plan.stockCode.length < 4) {
      throw new Error('证券代码格式不正确');
    }

    // 验证价格
    if (plan.currentPrice <= 0) {
      throw new Error('证券价格必须大于0');
    }

    // 验证管理费率
    if (plan.managementFee < 0 || plan.managementFee > 5) {
      throw new Error('管理费率应在0-5%之间');
    }
  }

  // 计算证券投资计划的总金额
  calculateTotalAmount(shares: number, averagePrice: number): number {
    return shares * averagePrice;
  }

  // 计算手数
  calculateLots(shares: number, lotSize: number = 100): number {
    return Math.floor(shares / lotSize);
  }

  // 验证并调整份额为手数的整数倍
  adjustSharesToLots(shares: number, lotSize: number = 100): number {
    return Math.floor(shares / lotSize) * lotSize;
  }

  // 计算年化管理费用
  calculateAnnualManagementFee(totalAmount: number, managementFee: number): number {
    return totalAmount * (managementFee / 100);
  }
}

// 创建默认服务实例 - 使用Supabase
export const stockPlanService = new StockPlanService({
  type: 'supabase',
  supabaseUrl: import.meta.env.VITE_SUPABASE_URL,
  supabaseKey: import.meta.env.VITE_SUPABASE_ANON_KEY
});

// 导出服务类
export { StockPlanService as StockPlanService };